import pytest  # used for our unit tests
from chromadb.execution.expression.operator import Key

# function to test
# (The Key class as provided above is assumed to be present in the test context.)

# -------------------------
# Unit tests for __hash__
# -------------------------

class TestKeyHashBasic:
    """Basic Test Cases for Key.__hash__"""

    def test_hash_equality_for_same_name(self):
        # Two Key instances with the same name should have the same hash
        k1 = Key("abc")
        k2 = Key("abc")
        # They should also be equal as dict keys
        d = {k1: "foo"}

    def test_hash_inequality_for_different_names(self):
        # Two Key instances with different names should have different hashes
        k1 = Key("abc")
        k2 = Key("def")

    def test_hash_with_empty_string(self):
        # Hash of empty string Key should be same as hash("")
        k = Key("")

    def test_hash_with_special_characters(self):
        # Hash should work with special characters
        k = Key("!@#$%^&*()_+-=")

    def test_hash_with_unicode(self):
        # Hash should work with unicode characters
        k = Key("ключ")  # Russian for "key"

    def test_hash_with_numbers_in_string(self):
        # Hash should work with numeric strings
        k = Key("123456")


class TestKeyHashEdge:
    """Edge Test Cases for Key.__hash__"""

    def test_hash_with_long_string(self):
        # Hash should work with a long string
        long_str = "a" * 1000
        k = Key(long_str)

    def test_hash_with_whitespace(self):
        # Hash should distinguish between strings with and without whitespace
        k1 = Key("abc")
        k2 = Key(" abc ")

    
#------------------------------------------------
from typing import Any

# imports
import pytest
from chromadb.execution.expression.operator import Key

# Initialize predefined key constants
Key.ID = Key("#id")
Key.DOCUMENT = Key("#document")
Key.EMBEDDING = Key("#embedding")
Key.METADATA = Key("#metadata")
Key.SCORE = Key("#score")

# unit tests

# --------- BASIC TEST CASES ---------

def test_hash_identical_names_equal():
    """Keys with the same name should have the same hash."""
    k1 = Key("foo")
    k2 = Key("foo")

def test_hash_different_names_not_equal():
    """Keys with different names should have different hashes (likely)."""
    k1 = Key("foo")
    k2 = Key("bar")

def test_hash_predefined_constants():
    """Predefined constants should have hashes equal to their string name."""

def test_hash_works_in_set():
    """Key objects should be usable in sets and as dict keys."""
    s = set()
    k1 = Key("foo")
    k2 = Key("foo")
    k3 = Key("bar")
    s.add(k1)
    s.add(k2)  # Should not add a new element (same name)
    s.add(k3)

def test_hash_consistency():
    """Hash value should be consistent across multiple calls."""
    k = Key("foo")
    h1 = hash(k)
    h2 = hash(k)

# --------- EDGE TEST CASES ---------

def test_hash_empty_string():
    """Key with empty string should hash the same as empty string."""
    k = Key("")

def test_hash_special_characters():
    """Keys with special/unicode characters should hash as expected."""
    k1 = Key("!@# $%^&*()_+")
    k2 = Key("你好世界")
    k3 = Key("foo\nbar\tbaz")

def test_hash_long_string():
    """Key with a very long string name should hash as the string."""
    long_str = "a" * 500
    k = Key(long_str)

def test_hash_negative_hash():
    """Hash can be negative; ensure no error is raised."""
    # Find a string with negative hash (platform-dependent, but usually possible)
    # We'll try a few, but the test is mainly that negative hashes don't break anything
    candidates = ["foo", "bar", "baz", "qux", "a" * 100]
    for s in candidates:
        k = Key(s)
        h = hash(k)
        # No exception means pass

def test_hash_collision_handling():
    """Even if two different names have the same hash, set/dict uses __eq__ to distinguish."""
    # It's hard to force a hash collision, but we can simulate it by monkeypatching
    # Instead, we just show that set/dict uses __eq__ as well as __hash__
    k1 = Key("foo")
    k2 = Key("foo")
    k3 = Key("bar")
    d = {k1: 1}
    d[k2] = 2  # Should overwrite, as names are equal
    d[k3] = 3  # Should add new

def test_hash_non_string_name_type():
    """If a non-string is passed, ensure hash is still computed (should not happen per type hint)."""
    # This is not recommended usage, but let's test for robustness.
    k = Key(123)  # type: ignore

def test_hash_mutation_does_not_affect_hash():
    """Changing the name after construction changes the hash (not recommended, but possible)."""
    k = Key("foo")
    h1 = hash(k)
    k.name = "bar"
    h2 = hash(k)

# --------- LARGE SCALE TEST CASES ---------

def test_hash_large_number_of_keys_unique():
    """Hashes for 1000 unique Key names should be unique (very high probability)."""
    keys = [Key(f"key_{i}") for i in range(1000)]
    hashes = set(hash(k) for k in keys)

def test_hash_large_number_of_duplicates():
    """All Keys with the same name should have the same hash, even in large numbers."""
    keys = [Key("duplicate") for _ in range(1000)]
    hashes = set(hash(k) for k in keys)

def test_hash_performance_large_scale(benchmark):
    """Performance: hashing 1000 keys should be fast."""
    keys = [Key(f"key_{i}") for i in range(1000)]
    def hash_all():
        for k in keys:
            hash(k)
    benchmark(hash_all)  # pytest-benchmark will measure performance

def test_hash_distribution_large_scale():
    """Distribution: Hashes of 1000 keys should be well distributed (no pathological clustering)."""
    keys = [Key(f"key_{i}") for i in range(1000)]
    hashes = [hash(k) for k in keys]
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
from chromadb.execution.expression.operator import Key

def test_Key___hash__():
    Key.__hash__(Key(''))